﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using NUnit.Framework;
using NUnit.Mocks;
using Sistema_Totem.Datos.SqlServer;
using Sistema_Totem.Logica.Clases;
using System.Data;
using System.Data.SqlClient;
using Sistema_Totem.Logica.Excepciones;


/// <summary>
/// Pruebas unitarias para los metodos de  SqlServerActor.
/// </summary>


namespace Sistema_Totem.Pruebas
{
    [TestFixture]
    public class PruebaSqlActor
    {
        #region Prueba Consultar Detalle Actor
        [Test]
        /// <summary>
        /// Pruebas unitaria para el metodo de Consultar Detalle Actor. Debe existir un Actor con los datos que
        /// se encuentran en la prueba para comprobar la consulta del mismo.
        /// Se crea un actor con datos de prueba (el mismo que esta almacenado), luego se llama al metodo 
        /// ConsultarDetalleActor(idActor), se usa el metodo equals para garantizar la igualdad de ambos actores
        /// (el de prueba y el que se esta consultando)
        /// </summary>

        public void PruebaConsultarDetalleActorSqlActor()
        {
            Actor actorDetalle = new Actor();
            Actor detalleActor = new Actor();
            actorDetalle.IdActor = 1;
            actorDetalle.Nombre = "Jordi Consulta";
            actorDetalle.Estatus = "status de prueba Consulta";
            actorDetalle.Descripcion = "descripcion de prueba Consulta";
            SqlServerActor actorConsultar = new SqlServerActor();
            detalleActor = actorConsultar.ConsultarDetalleActor(1);
            Assert.IsNotNull(detalleActor);
            Assert.IsTrue(actorDetalle.Equals(detalleActor));

        }
        #endregion Prueba Consultar Detalle Actor;

        #region Prueba Consultar Actor Por Proyecto
        /// <summary>
        /// Pruebas unitaria para la consulta de los actores segun el proyecto al que estan asociados.
        /// se crean dos listas de actores, una lista con valores de prueba para la comparacion (deben estar almacenados
        /// con los datos que se muestran en la prueba y la otra lista con los valores que se obtendran al ejecutar el metodo.
        /// Se comparan ambas listas para garantizar la funcionalidad del metodo.
        /// </summary>
        [Test]

        public void PruebaConsultarActorProyectoSqlActor()
        {
            List<Actor> actores = new List<Actor>();
            List<Actor> actoresComparacion = new List<Actor>();
            actoresComparacion.Add(new Actor(2, "Jordi Consulta", "descripcion de prueba Consulta", "status de prueba Consulta")); // actor de prueba
            actoresComparacion.Add(new Actor(3, "Antonio Consulta", "descripcion de prueba Consulta", "status de prueba Consulta")); // actor de prueba
            actoresComparacion.Add(new Actor(4, "Andrea Consulta", "descripcion de prueba Consulta", "status de prueba Consulta")); // actor de prueba
            SqlServerActor actorConsultar = new SqlServerActor();
            actores = actorConsultar.ConsultarActor(1);
            Assert.IsNotNull(actores);
            Assert.IsNotEmpty(actores);
            Assert.IsTrue(actores[0].Equals(actoresComparacion[0]));
            Assert.IsTrue(actores[1].Equals(actoresComparacion[1]));
            Assert.IsTrue(actores[2].Equals(actoresComparacion[2]));
        }
        #endregion Prueba Consultar Actor Por Proyecto;

        #region Prueba Agregar Actor
        /// <summary>
        /// Pruebas unitaria para el metodo Agregar Actor. Se crea un Actor de prueba (con datos conocidos).
        /// el metodo AgregarActor devuelve un valor entero "1" si fue exitosamente ejecutado, se compara este valor y ademas
        /// se consulta el detalle del actor (una vez almacenado) con el actor de prueba de manera que se verifique que 
        /// fue efectivamente agregado.
        /// </summary>
        [Test]

        public void PruebaAgregarActorSqlActor()
        {
            Actor actorPrueba = new Actor(1, "Jordi Agregar", "descripcion de prueba", "status de prueba");
            SqlServerActor actorInsertar = new SqlServerActor();
            int agregarActor = actorInsertar.AgregarActor(actorPrueba, "1");
            //  Actor actorPrueba2 = actorInsertar.ConsultarDetalleActor(1);
            Assert.AreEqual(1, agregarActor);
            Assert.AreEqual(true, actorPrueba.Equals(actorInsertar.ConsultarDetalleActor(1)));

        }
        #endregion Prueba Agregar Actor;

        #region Prueba Eliminar Actor
        /// <summary>
        /// Pruebas unitarias para eliminar actor. Se crea un actor el cual va a contener los datos del actor que se quiere eliminar
        /// Se utiliza el idActor para ejecutar el metodo "eliminarActor", este metodo retorna el valor entero "1" cuando es 
        /// ejcutado exitosamente (se verifica este valor) ademas se verifica que la consulta del "detalleActor" con el idActor
        /// que se utilizo para la eliminacion, es null (fue eliminado).
        /// </summary>
        [Test]

        public void PruebaEliminarActorSqlActor()
        {
            Actor actorEliminado = new Actor();
            SqlServerActor eliminarActor = new SqlServerActor();
            actorEliminado = new Actor(2, "Jordi Consulta", "descripcion de prueba Consulta", "status de prueba Consulta");
            int eliminadoActor = eliminarActor.EliminarActor(2);
            Assert.AreEqual(1, eliminadoActor);
            Assert.IsNull(actorEliminado.ConsultarDetalleActor(2));

        }
        #endregion Prueba Eliminar Actor;

        #region Prueba Consultar Actor CU
        /// <summary>
        /// Pruebas unitaria para la consulta de los actores segun el caso de uso al que estan asociados.
        /// se crean dos listas de actores, una lista con valores de prueba para la comparacion (deben estar almacenados
        /// con los datos que se muestran en la prueba y la otra lista con los valores que se obtendran al ejecutar el metodo.
        /// Se comparan ambas listas para garantizar la funcionalidad del metodo.
        /// </summary>
        [Test]

        public void PruebaConsultarActorACUSqlActor()
        {
            List<Actor> actores = new List<Actor>();
            List<Actor> actoresComparacion = new List<Actor>();
            actoresComparacion.Add(new Actor(5, "Jordi Consulta", "descripcion de prueba Consulta", "status de prueba Consulta")); // actor de prueba
            actoresComparacion.Add(new Actor(3, "Antonio Consulta", "descripcion de prueba Consulta", "status de prueba Consulta")); // actor de prueba
            actoresComparacion.Add(new Actor(4, "Andrea Consulta", "descripcion de prueba Consulta", "status de prueba Consulta")); // actor de prueba
            SqlServerActor actorConsultar = new SqlServerActor();
            actores = actorConsultar.ConsultarActorCasoDeUso(1);
            Assert.IsNotNull(actores);
            Assert.IsNotEmpty(actores);
            Assert.AreEqual(actores[0].IdActor, actoresComparacion[0].IdActor);
            Assert.AreEqual(actores[0].Nombre, actoresComparacion[0].Nombre);
        }

        #endregion Prueba Consultar Actor CU;

        #region Prueba Asignar Actor A CU
        /// <summary>
        /// Pruebas unitaria para el metodo AsignarActor a caso de uso. El metodo retorna un valor entero "1" si se ejecuto 
        /// correctamente. Se ejecuta el metodo con el idActor = 4 y el idCU = 1 (deben estar almacenados previamente). 
        /// se crea una lista "List<Actor> actores" la cual contendra los actores asociados al caso de uso con idCU = 1.
        /// Se compara que el valor devuelto por la ejecucion de "asignarActorPrueba.AsignarActor(4,"1")" sea igual al valor entero "1"
        /// ademas se comparan el idActor y nombre de los actores con aquellos asociados al caso de uso en cuestion.
        /// </summary>
        [Test]

        public void PruebaAsignarActorACUSqlActor()
        {
            SqlServerActor asignarActorPrueba = new SqlServerActor();
            int asignarActorACU = asignarActorPrueba.AsignarActor(4, "1"); // se asume que el actor de id = 4 y el CU de id="1" estan insertados
            List<Actor> actores = new List<Actor>();
            SqlServerActor actorConsultarAsignacion = new SqlServerActor();
            actores = actorConsultarAsignacion.ConsultarActorCasoDeUso(1);
            Assert.AreEqual(1, asignarActorACU);
            Assert.IsNotNull(actores[0]);
            Assert.AreEqual(actores[0].IdActor, asignarActorPrueba.ConsultarDetalleActor(4).IdActor);
            Assert.AreEqual(actores[0].Nombre, asignarActorPrueba.ConsultarDetalleActor(4).Nombre);
        }
        #endregion Prueba Asignar Actor A CU;

        #region Prueba Quitar Actor CU
        /// <summary>
        /// Pruebas unitaria para el metodo QuitarActorCasoDeUso. El metodo retorna un valor entero "1" si se ejecuto 
        /// correctamente. Se ejecuta <int quitarActor = actorQuitar.QuitarActorCasoDeUso(5, "1")> (deben estar almacenados 
        /// previamente. Se asume que existe el Caso de uso <id = 1> con un actor asociado <id = 5)>. 
        /// se crea una lista <List<Actor>   la cual contendra los actores asociados al caso de uso con idCU = 1.
        /// Se recorren todos los objetos de la lista comparando el idActor con el idActor=5 (eliminado) para comprobar 
        /// que no se encuentra en la lista con aquellos asociados al caso de uso en cuestion.
        /// </summary>
        [Test]

        public void PruebaQuitarActorCUSqlActor()
        {
            List<Actor> actores = new List<Actor>();
            SqlServerActor actorQuitar = new SqlServerActor();
            int quitarActor = actorQuitar.QuitarActorCasoDeUso(5, "1");
            actores = actorQuitar.ConsultarActorCasoDeUso(1);
            Assert.AreEqual(1, quitarActor);
            int i = 0;
            while (i <= (actores.Count - 1)) 
            {
                Assert.AreNotEqual(5, actores[i].IdActor);
                i++;
            }


        }

        #endregion Prueba Quitar Actor CU;

        #region Prueba Obtener Id Proyecto
        /// <summary>
        /// Pruebas unitaria para el metodo ObtenerIdProyecto. El metodo retorna un valor entero "1" si se ejecuto 
        /// correctamente. Se ejecuta <int idProyectoObtenido = idProyectoBuscar.ObtenerIdProyecto("Prueba")> en donde 
        /// se asume que existe un Proyecto con Nombre = "Prueba" y idProyecto = 1. se comprueba que el valor obtenido 
        /// sea idProyecto = 1
        /// </summary>
        [Test]

        public void PruebaObtenerIdProyectoSqlActor()
        {

            SqlServerActor idProyectoBuscar = new SqlServerActor();
            int idProyectoObtenido = idProyectoBuscar.ObtenerIdProyecto("Prueba");
            Assert.AreEqual(1, idProyectoObtenido);
        }

        #endregion Prueba Obtener Id Proyecto ;

        #region Prueba Cambiar Estatus Actor
        /// <summary>
        /// Pruebas unitaria para el metodo CambiarEstatusActor. El metodo retorna un valor entero "1" si se ejecuto 
        /// correctamente.
        /// Se ejecuta < Actor actorPruebaEstatus = new Actor(1, "Jordi Estatus", "descripcion de prueba Estatus", "Estatus de prueba")>
        /// este <actor> se agrega y asigna al proyecto con idProyecto = 1, se comprueba que el valor retornado por el metodo
        /// AgregarActor es igual al valor entero "1", se ejectuta < Actor actorACambiar = cambiarEstatusActor.ConsultarDetalleActor(1);>
        /// para obtener el detalle del actor insertado anteriormente con idActor = 1, se ejecuta 
        /// <int estatusCambiado = cambiarEstatusActor.CambiarEstatusActor(actorACambiar, "Inactivo");> el cual devuelve el valor
        /// entero "1" si se efectuó exitosamente ademas de cambiar el Estatus del actor recien agregado "Estatus de Prueba"
        /// a "Inactivo". Se comparan los Estatus "antes y "despues", los valores retornados por los metodos y el 
        /// nuevo Estatus de "Inactivo"
        /// </summary>
        [Test]

        public void PruebaCambiarEstatusActorSqlActor()
        {

            SqlServerActor cambiarEstatusActor = new SqlServerActor();
            Actor actorPruebaEstatus = new Actor(1, "Jordi Estatus", "descripcion de prueba Estatus", "Estatus de prueba");
            SqlServerActor actorInsertar = new SqlServerActor();
            int agregarActor = actorInsertar.AgregarActor(actorPruebaEstatus, "1");
            Assert.AreEqual(1, agregarActor);
            Actor actorACambiar = cambiarEstatusActor.ConsultarDetalleActor(1);
            int estatusCambiado = cambiarEstatusActor.CambiarEstatusActor(actorACambiar, "Inactivo");
            Actor actorCambiado = cambiarEstatusActor.ConsultarDetalleActor(1);
            Assert.AreEqual(1, estatusCambiado);
            Assert.AreNotEqual(actorPruebaEstatus.Estatus, actorCambiado.Estatus);
            Assert.AreEqual("Inactivo", actorCambiado.Estatus);



        }

        #endregion Prueba Cambiar estatus Actor;

        #region Prueba Editar Actor
        /// <summary>
        /// Prueba unitaria para el metodo EditarActor. Se crea un actor de prueba <Actor actorPrueba> con la finalidad
        /// de editar los datos de un actor previamente almacenado con idActor=1. El metodo <EditarActor> retorna un valor entero "1"
        /// si se ejecuto exitosamente. Se comparan los detalles (antes y despues) del actor con idActor = 1.
        /// </summary>
        [Test]

        public void PruebaEditarActorSqlActor()
        {

            SqlServerActor editarActor = new SqlServerActor();
            Actor actorPrueba = new Actor(1, "Jordi Editado", "descripcion de edicion", "Editado");
            Actor actorNoEditado = editarActor.ConsultarDetalleActor(1);
            int actorEditado = editarActor.EditarActor(actorPrueba, 1);
            Assert.AreEqual(1, actorEditado);
            Actor ActorEditado = editarActor.ConsultarDetalleActor(1);
            Assert.AreEqual(actorPrueba.Nombre, ActorEditado.Nombre);
     
        }

        #endregion Prueba Editar Actor;

        #region Prueba Buscar Data
        /// <summary>
        /// Prueba unitaria para el metodo BuscarData. Se comprueba que una llamada a este metodo con valores conocidos
        /// retorna "algo" si se encuentra almacenados los datos introducidos como parametro BuscarData. se comprueba ademas
        /// que en el caso de poseer parametros que no existen en la base de datos el resultado de la ejecucion es un 
        /// <SqlDataReader reader> el cual es NULL.
        /// </summary>
        [Test]

        public void PruebaBuscarDataSqlActor()
        {

            List<String> variables = new List<String>();
            List<String> valores = new List<String>();
            SqlServerActor buscarData = new SqlServerActor();

            variables.Add("idActor");
            valores.Add("10");
            Conexion conexion = new Conexion();

            SqlDataReader reader = buscarData.BuscarData (conexion, "[dbo].[ConsultarDetalleActor]", variables, valores);
            Assert.IsNotNull(reader.Read());
            variables.Clear();
            valores.Clear();
            variables.Add("idActor");
            valores.Add("1234567");

            SqlDataReader readerMalo = buscarData.BuscarData(conexion, "[dbo].[ConsultarDetalleActor]", variables, valores);
            Assert.IsFalse(readerMalo.Read());

        }

        #endregion Prueba Buscar Data;

        #region Prueba Ejecutar Query
        /// <summary>
        /// Prueba unitaria para el metodo EjecutarQuery. Se comprueba que la llamada a este metodo con valores conocidos, existentes
        /// en la base de datos retorna el valor entero "1" (ejecucion exitosa). Para esto se quiere cambiar el Estatus del actor con 
        /// idActor=1 a Estatus = "PruebaEjecutarQuery". Se consulta luego el detalle del actor con idActor=1 y se comprueba
        /// que su Estatus fue efectivamente modificado lo que implica que la funcionalidad del metodo es la esperada.
        /// </summary>
        [Test]

        public void PruebaEjecutarQuerySqlActor()
        {
            List<String> variables = new List<String>();
            List<String> valores = new List<String>();
            variables.Add("idActor");
            variables.Add("estatusNuevo");
            valores.Add("1");
            valores.Add("PruebaEjecutarQuery");
            SqlServerActor pruebaEjecutarQuery = new SqlServerActor();
            Conexion conexion = new Conexion();
            Actor actorConsultarEjecutarQuery = new Actor();
            int resultado = pruebaEjecutarQuery.EjecutarQuery(conexion, "[dbo].[CambiarEstatusActor]", variables, valores);
            Assert.AreEqual(1, resultado);
            actorConsultarEjecutarQuery= pruebaEjecutarQuery.ConsultarDetalleActor(1);
            Assert.AreEqual("PruebaEjecutarQuery", actorConsultarEjecutarQuery.Estatus);

        }

        #endregion Prueba Ejecutar Query;

    }
}